/* 
    // 作用域链：代码执行环境所创建的作用域链往外层查找，直到搜索全局对象为止。
    var a = 1;
    var func1 = function() {
        var b = 2;
        var func2 = function() {
            var c = 3;
            console.log(b);
            console.log(a);
        };

        func2();
        console.log(c);
    }

    func1();
 */
/* 
    // 全局变量的生存周期，全局变量的生存周期时永久的，除非手动摧毁这个变量
    // 局部变量的生存周期：退出该函数时，这些变量及失去他们的价值，他们会随着函数的调用结束而被摧毁。

    var func = function() {
        var a = 1;
        return function() {
            a++;
            console.log(a)
        }
    };
    var f = func();
    // 这里形成了一个闭包：这里执行func()时，f是内部匿名函数的引用，此时func在执行时所创建的执行环境能够被访问到，因此不能被摧毁。
    f();// 2
    f();// 3
    f();// 4
    f();// 5
 */
/* 
    // 遍历容器下的div, 点击每个div并输出下标 
    var node_1_s = document.querySelector('.part_2-2-1').querySelectorAll('div');
    for(var k = 0; k < node_1_s.length; k++) {
        node_1_s[k].onclick = function() {
            console.log(k)
        }
    }

    var node_2_s = document.querySelector('.part_2-2-2').querySelectorAll('div');
    for(var i = 0; i < node_2_s.length; i++) {
        (function(i) {
            node_2_s[i].onclick = function() {
                console.log(i);
            }
        })(i)
    }
 */

// 1.变量的封装
/* 
    // 通过闭包封装 类型检测函数
    var Type = {};
    for (var i = 0, type; type = ['String', 'Array', 'Number', 'Object'][i++];) {
        (function(type) {
            Type['is'+type] = function(obj) {
                return Object.prototype.toString.call(obj) === '[object '+type+']';
            }
        })(type)
    }
    console.log(Type)
    console.log(Type.isString('str'));
    console.log(Type.isNumber(5));
    console.log(Type.isNumber('sstr'));
*/
/* 
    var cache = {};
    var mult = function() {
        var argus = Array.prototype.join.call(arguments, ',');
        if (cache[argus]) {
            return cache[argus]
        }

        var a = 1;

        for (var i = 0, l = arguments.length; i < l; i++) {
            a = a * arguments[i];
        }

        return cache[argus] = a;
    }

    console.time('a1')
    var result_1 = mult(1,2,3);
    console.log(result_1);
    console.timeEnd('a1');

    console.time('a2')
    var result_2 = mult(1,2,3);
    console.log(result_2);
    console.timeEnd('a2');
 */
/* 
    var mult = (function() {
        var cache = {};

        return function() {
            var argus = Array.prototype.join.call(arguments, ',');
            if (argus in cache) {
                return cache[argus]
            }

            var a = 1;
            for (var i = 0, l = arguments.length; i < l; i++) {
                a = a * arguments[i]
            }

            return cache[argus] = a;
        }
    })();

    console.time('a1')
    var result_1 = mult(1,2,3);
    console.log(result_1);
    console.timeEnd('a1');

    console.time('a2')
    var result_2 = mult(1,2,3);
    console.log(result_2);
    console.timeEnd('a2');
 */
/* 
    var mult = (function() {
        var cache = {};
        return function() {
        var argus = Array.prototype.join.call(arguments, ',');
        if (argus in cache) {
            return cache[argus]
        }
        
        var calculate = function() {
            var a = 1;
            for (var i = 0, l = arguments.length; i < l; i++) {
                a = a * arguments[i];
            }
            return a;
        }
        
        return cache[argus] = calculate.apply(null, arguments);
        }
    })();

    console.time('a1')
    var result_1 = mult(1,2,3);
    console.log(result_1);
    console.timeEnd('a1');

    console.time('a2')
    var result_2 = mult(1,2,3);
    console.log(result_2);
    console.timeEnd('a2');
 */


 // 2.延续局部变量的寿命